//
// NeL - bindings
// Copyright (C) 2010 Naush
//
//This program is free software: you can redistribute it and/or modify
//it under the terms of the GNU Affero General Public License as
//published by the Free Software Foundation, either version 3 of the
//License, or (at your option) any later version.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU Affero General Public License for more details.
//
//You should have received a copy of the GNU Affero General Public License
//along with this program.  If not, see <http://www.gnu.org/licenses/>.
package org.ryzom.nel.misc;

public class nelmisc implements nelmiscConstants {
  public static double getQuatEpsilon() {
    return nelmiscJNI.QuatEpsilon_get();
  }

  public static void incrementalBlend(SWIGTYPE_p_float value, float target, float absDelta) {
    nelmiscJNI.incrementalBlend(SWIGTYPE_p_float.getCPtr(value), target, absDelta);
  }

  public static void drawFullLine(float x0, float y0, float x1, float y1, SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t result) {
    nelmiscJNI.drawFullLine(x0, y0, x1, y1, SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t.getCPtr(result));
  }

  public static void drawLine(float x0, float y0, float x1, float y1, SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t result) {
    nelmiscJNI.drawLine(x0, y0, x1, y1, SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t.getCPtr(result));
  }

  public static void fastClamp8(SWIGTYPE_p_int v) {
    nelmiscJNI.fastClamp8(SWIGTYPE_p_int.getCPtr(v));
  }

  public static boolean testWildCard(String strIn, String wildCard) {
    return nelmiscJNI.testWildCard__SWIG_0(strIn, wildCard);
  }

  public static void splitString(String str, String separator, Vector_String retList) {
    nelmiscJNI.splitString(str, separator, Vector_String.getCPtr(retList), retList);
  }

  public static void splitUCString(ucstring ucstr, ucstring separator, SWIGTYPE_p_std__vectorT_ucstring_t retList) {
    nelmiscJNI.splitUCString(ucstring.getCPtr(ucstr), ucstr, ucstring.getCPtr(separator), separator, SWIGTYPE_p_std__vectorT_ucstring_t.getCPtr(retList));
  }

  public static void initNelLibrary(CLibrary lib) {
    nelmiscJNI.initNelLibrary(CLibrary.getCPtr(lib), lib);
  }

  public static long getBF_ALWAYS_OPENED() {
    return nelmiscJNI.BF_ALWAYS_OPENED_get();
  }

  public static long getBF_CACHE_FILE_ON_OPEN() {
    return nelmiscJNI.BF_CACHE_FILE_ON_OPEN_get();
  }

  public static void setSerialTypeToCStr(SWIGTYPE_p_p_char value) {
    nelmiscJNI.SerialTypeToCStr_set(SWIGTYPE_p_p_char.getCPtr(value));
  }

  public static SWIGTYPE_p_p_char getSerialTypeToCStr() {
    long cPtr = nelmiscJNI.SerialTypeToCStr_get();
    return (cPtr == 0) ? null : new SWIGTYPE_p_p_char(cPtr, false);
  }

  public static void displayBitStream(CBitMemStream msg, int beginbitpos, int endbitpos, CLog log) {
    nelmiscJNI.displayBitStream__SWIG_0(CBitMemStream.getCPtr(msg), msg, beginbitpos, endbitpos, CLog.getCPtr(log), log);
  }

  public static void displayBitStream(CBitMemStream msg, int beginbitpos, int endbitpos) {
    nelmiscJNI.displayBitStream__SWIG_1(CBitMemStream.getCPtr(msg), msg, beginbitpos, endbitpos);
  }

  public static long getDDS_HEADER() {
    return nelmiscJNI.DDS_HEADER_get();
  }

  public static long getDXT_HEADER() {
    return nelmiscJNI.DXT_HEADER_get();
  }

  public static long getPNG_HEADER() {
    return nelmiscJNI.PNG_HEADER_get();
  }

  public static long getJPG_HEADER() {
    return nelmiscJNI.JPG_HEADER_get();
  }

  public static short getMAX_MIPMAP() {
    return nelmiscJNI.MAX_MIPMAP_get();
  }

  public static void setNL3D_BlockMemoryAssertOnPurge(boolean value) {
    nelmiscJNI.NL3D_BlockMemoryAssertOnPurge_set(value);
  }

  public static boolean getNL3D_BlockMemoryAssertOnPurge() {
    return nelmiscJNI.NL3D_BlockMemoryAssertOnPurge_get();
  }

  public static long getNL_TASK_STACK_SIZE() {
    return nelmiscJNI.NL_TASK_STACK_SIZE_get();
  }

  public static double getPi() {
    return nelmiscJNI.Pi_get();
  }

  public static float frand(float mod) {
    return nelmiscJNI.frand(mod);
  }

  public static int fsgn(double f) {
    return nelmiscJNI.fsgn(f);
  }

  public static long raiseToNextPowerOf2(long v) {
    return nelmiscJNI.raiseToNextPowerOf2(v);
  }

  public static long getPowerOf2(long v) {
    return nelmiscJNI.getPowerOf2(v);
  }

  public static boolean isPowerOf2(int v) {
    return nelmiscJNI.isPowerOf2(v);
  }

  public static float degToRad(float deg) {
    return nelmiscJNI.degToRad(deg);
  }

  public static float radToDeg(float rad) {
    return nelmiscJNI.radToDeg(rad);
  }

  public static double isValidDouble(double v) {
    return nelmiscJNI.isValidDouble(v);
  }

  public static String toLower(String str) {
    return nelmiscJNI.toLower__SWIG_0(str);
  }

  public static char toLower(char ch) {
    return nelmiscJNI.toLower__SWIG_2(ch);
  }

  public static String toUpper(String str) {
    return nelmiscJNI.toUpper__SWIG_0(str);
  }

  public static SWIGTYPE_p_std__string strlwr(SWIGTYPE_p_std__string str) {
    return new SWIGTYPE_p_std__string(nelmiscJNI.strlwr__SWIG_0(SWIGTYPE_p_std__string.getCPtr(str)), false);
  }

  public static String strlwr(String str) {
    return nelmiscJNI.strlwr__SWIG_1(str);
  }

  public static SWIGTYPE_p_std__string strupr(SWIGTYPE_p_std__string str) {
    return new SWIGTYPE_p_std__string(nelmiscJNI.strupr__SWIG_0(SWIGTYPE_p_std__string.getCPtr(str)), false);
  }

  public static String strupr(String str) {
    return nelmiscJNI.strupr__SWIG_1(str);
  }

  public static int stricmp(String lhs, String rhs) {
    return nelmiscJNI.stricmp(lhs, rhs);
  }

  public static int strnicmp(String lhs, String rhs, long n) {
    return nelmiscJNI.strnicmp(lhs, rhs, n);
  }

  public static int nlstricmp(String lhs, String rhs) {
    return nelmiscJNI.nlstricmp__SWIG_0(lhs, rhs);
  }

  public static int nlfseek64(SWIGTYPE_p_FILE stream, long offset, int origin) {
    return nelmiscJNI.nlfseek64(SWIGTYPE_p_FILE.getCPtr(stream), offset, origin);
  }

  public static long nlftell64(SWIGTYPE_p_FILE stream) {
    return nelmiscJNI.nlftell64(SWIGTYPE_p_FILE.getCPtr(stream));
  }

  public static void nlSleep(long ms) {
    nelmiscJNI.nlSleep(ms);
  }

  public static long getThreadId() {
    return nelmiscJNI.getThreadId();
  }

  public static String stringFromVector(SWIGTYPE_p_std__vectorT_unsigned_char_t v, boolean limited) {
    return nelmiscJNI.stringFromVector__SWIG_0(SWIGTYPE_p_std__vectorT_unsigned_char_t.getCPtr(v), limited);
  }

  public static String stringFromVector(SWIGTYPE_p_std__vectorT_unsigned_char_t v) {
    return nelmiscJNI.stringFromVector__SWIG_1(SWIGTYPE_p_std__vectorT_unsigned_char_t.getCPtr(v));
  }

  public static long atoiInt64(String ident, long base) {
    return nelmiscJNI.atoiInt64__SWIG_0(ident, base);
  }

  public static long atoiInt64(String ident) {
    return nelmiscJNI.atoiInt64__SWIG_1(ident);
  }

  public static void itoaInt64(long number, String str, long base) {
    nelmiscJNI.itoaInt64__SWIG_0(number, str, base);
  }

  public static void itoaInt64(long number, String str) {
    nelmiscJNI.itoaInt64__SWIG_1(number, str);
  }

  public static String bytesToHumanReadable(String bytes) {
    return nelmiscJNI.bytesToHumanReadable__SWIG_0(bytes);
  }

  public static String bytesToHumanReadable(java.math.BigInteger bytes) {
    return nelmiscJNI.bytesToHumanReadable__SWIG_1(bytes);
  }

  public static long humanReadableToBytes(String str) {
    return nelmiscJNI.humanReadableToBytes(str);
  }

  public static String secondsToHumanReadable(long time) {
    return nelmiscJNI.secondsToHumanReadable(time);
  }

  public static long fromHumanReadable(String str) {
    return nelmiscJNI.fromHumanReadable(str);
  }

  public static boolean launchProgram(String programName, String arguments) {
    return nelmiscJNI.launchProgram(programName, arguments);
  }

  public static boolean killProgram(long pid) {
    return nelmiscJNI.killProgram(pid);
  }

  public static boolean abortProgram(long pid) {
    return nelmiscJNI.abortProgram(pid);
  }

  public static void displayByteBits(short b, long nbits, int beginpos, boolean displayBegin, CLog log) {
    nelmiscJNI.displayByteBits(b, nbits, beginpos, displayBegin, CLog.getCPtr(log), log);
  }

  public static void displayDwordBits(long b, long nbits, int beginpos, boolean displayBegin, CLog log) {
    nelmiscJNI.displayDwordBits(b, nbits, beginpos, displayBegin, CLog.getCPtr(log), log);
  }

  public static boolean openURL(String url) {
    return nelmiscJNI.openURL(url);
  }

  public static boolean openDoc(String document) {
    return nelmiscJNI.openDoc(document);
  }

  public static float favoid0(float x) {
    return nelmiscJNI.favoid0(x);
  }

  public static double davoid0(double x) {
    return nelmiscJNI.davoid0(x);
  }

  public static void setErrorLog(CImposterLog value) {
    nelmiscJNI.ErrorLog_set(CImposterLog.getCPtr(value), value);
  }

  public static CImposterLog getErrorLog() {
    long cPtr = nelmiscJNI.ErrorLog_get();
    return (cPtr == 0) ? null : new CImposterLog(cPtr, false);
  }

  public static void setWarningLog(CImposterLog value) {
    nelmiscJNI.WarningLog_set(CImposterLog.getCPtr(value), value);
  }

  public static CImposterLog getWarningLog() {
    long cPtr = nelmiscJNI.WarningLog_get();
    return (cPtr == 0) ? null : new CImposterLog(cPtr, false);
  }

  public static void setInfoLog(CImposterLog value) {
    nelmiscJNI.InfoLog_set(CImposterLog.getCPtr(value), value);
  }

  public static CImposterLog getInfoLog() {
    long cPtr = nelmiscJNI.InfoLog_get();
    return (cPtr == 0) ? null : new CImposterLog(cPtr, false);
  }

  public static void setDebugLog(CImposterLog value) {
    nelmiscJNI.DebugLog_set(CImposterLog.getCPtr(value), value);
  }

  public static CImposterLog getDebugLog() {
    long cPtr = nelmiscJNI.DebugLog_get();
    return (cPtr == 0) ? null : new CImposterLog(cPtr, false);
  }

  public static void setAssertLog(CImposterLog value) {
    nelmiscJNI.AssertLog_set(CImposterLog.getCPtr(value), value);
  }

  public static CImposterLog getAssertLog() {
    long cPtr = nelmiscJNI.AssertLog_get();
    return (cPtr == 0) ? null : new CImposterLog(cPtr, false);
  }

  public static void setDefaultMemDisplayer(CMemDisplayer value) {
    nelmiscJNI.DefaultMemDisplayer_set(CMemDisplayer.getCPtr(value), value);
  }

  public static CMemDisplayer getDefaultMemDisplayer() {
    long cPtr = nelmiscJNI.DefaultMemDisplayer_get();
    return (cPtr == 0) ? null : new CMemDisplayer(cPtr, false);
  }

  public static void setDefaultMsgBoxDisplayer(CMsgBoxDisplayer value) {
    nelmiscJNI.DefaultMsgBoxDisplayer_set(CMsgBoxDisplayer.getCPtr(value), value);
  }

  public static CMsgBoxDisplayer getDefaultMsgBoxDisplayer() {
    long cPtr = nelmiscJNI.DefaultMsgBoxDisplayer_get();
    return (cPtr == 0) ? null : new CMsgBoxDisplayer(cPtr, false);
  }

  public static void createDebug(String logPath, boolean logInFile, boolean eraseLastLog) {
    nelmiscJNI.createDebug__SWIG_0(logPath, logInFile, eraseLastLog);
  }

  public static void createDebug(String logPath, boolean logInFile) {
    nelmiscJNI.createDebug__SWIG_1(logPath, logInFile);
  }

  public static void createDebug(String logPath) {
    nelmiscJNI.createDebug__SWIG_2(logPath);
  }

  public static void createDebug() {
    nelmiscJNI.createDebug__SWIG_3();
  }

  public static void destroyDebug() {
    nelmiscJNI.destroyDebug();
  }

  public static void changeLogDirectory(String dir) {
    nelmiscJNI.changeLogDirectory(dir);
  }

  public static String getLogDirectory() {
    return nelmiscJNI.getLogDirectory();
  }

  public static void setAssert(boolean _assert) {
    nelmiscJNI.setAssert(_assert);
  }

  public static void beep(long freq, long duration) {
    nelmiscJNI.beep(freq, duration);
  }

  public static void setCrashCallback(SWIGTYPE_p_f___std__string crashCallback) {
    nelmiscJNI.setCrashCallback(SWIGTYPE_p_f___std__string.getCPtr(crashCallback));
  }

  public static boolean isCrashAlreadyReported() {
    return nelmiscJNI.isCrashAlreadyReported();
  }

  public static void setCrashAlreadyReported(boolean state) {
    nelmiscJNI.setCrashAlreadyReported(state);
  }

  public static void setDisableNLDebug(boolean value) {
    nelmiscJNI.DisableNLDebug_set(value);
  }

  public static boolean getDisableNLDebug() {
    return nelmiscJNI.DisableNLDebug_get();
  }

  public static boolean _assert_stop(SWIGTYPE_p_bool ignoreNextTime, int line, String file, String funcName, String exp) {
    return nelmiscJNI._assert_stop(SWIGTYPE_p_bool.getCPtr(ignoreNextTime), line, file, funcName, exp);
  }

  public static void _assertex_stop_0(SWIGTYPE_p_bool ignoreNextTime, int line, String file, String funcName, String exp) {
    nelmiscJNI._assertex_stop_0(SWIGTYPE_p_bool.getCPtr(ignoreNextTime), line, file, funcName, exp);
  }

  public static boolean _assertex_stop_1(SWIGTYPE_p_bool ignoreNextTime) {
    return nelmiscJNI._assertex_stop_1(SWIGTYPE_p_bool.getCPtr(ignoreNextTime));
  }

  public static void getCallStack(SWIGTYPE_p_std__string result, int skipNFirst) {
    nelmiscJNI.getCallStack__SWIG_0(SWIGTYPE_p_std__string.getCPtr(result), skipNFirst);
  }

  public static void getCallStack(SWIGTYPE_p_std__string result) {
    nelmiscJNI.getCallStack__SWIG_1(SWIGTYPE_p_std__string.getCPtr(result));
  }

  public static void getCallStackAndLog(SWIGTYPE_p_std__string result, int skipNFirst) {
    nelmiscJNI.getCallStackAndLog__SWIG_0(SWIGTYPE_p_std__string.getCPtr(result), skipNFirst);
  }

  public static void getCallStackAndLog(SWIGTYPE_p_std__string result) {
    nelmiscJNI.getCallStackAndLog__SWIG_1(SWIGTYPE_p_std__string.getCPtr(result));
  }

  public static void nlFatalError(String format) {
    nelmiscJNI.nlFatalError(format);
  }

  public static void nlError(String format) {
    nelmiscJNI.nlError(format);
  }

  public static int getLastError() {
    return nelmiscJNI.getLastError();
  }

  public static String formatErrorMessage(int errorCode) {
    return nelmiscJNI.formatErrorMessage(errorCode);
  }

  public static SWIGTYPE_p_void nlLoadLibrary(String libName) {
    long cPtr = nelmiscJNI.nlLoadLibrary(libName);
    return (cPtr == 0) ? null : new SWIGTYPE_p_void(cPtr, false);
  }

  public static boolean nlFreeLibrary(SWIGTYPE_p_void libHandle) {
    return nelmiscJNI.nlFreeLibrary(SWIGTYPE_p_void.getCPtr(libHandle));
  }

  public static SWIGTYPE_p_void nlGetSymbolAddress(SWIGTYPE_p_void libHandle, String symbolName) {
    long cPtr = nelmiscJNI.nlGetSymbolAddress(SWIGTYPE_p_void.getCPtr(libHandle), symbolName);
    return (cPtr == 0) ? null : new SWIGTYPE_p_void(cPtr, false);
  }

  public static String getNlLibSuffix() {
    return nelmiscJNI.nlLibSuffix_get();
  }

  public static long getOptFastFloorCWStackSize() {
    return nelmiscJNI.OptFastFloorCWStackSize_get();
  }

  public static void setOptFastFloorCWStack(SWIGTYPE_p_int value) {
    nelmiscJNI.OptFastFloorCWStack_set(SWIGTYPE_p_int.getCPtr(value));
  }

  public static SWIGTYPE_p_int getOptFastFloorCWStack() {
    long cPtr = nelmiscJNI.OptFastFloorCWStack_get();
    return (cPtr == 0) ? null : new SWIGTYPE_p_int(cPtr, false);
  }

  public static void setOptFastFloorCWStackPtr(SWIGTYPE_p_int value) {
    nelmiscJNI.OptFastFloorCWStackPtr_set(SWIGTYPE_p_int.getCPtr(value));
  }

  public static SWIGTYPE_p_int getOptFastFloorCWStackPtr() {
    long cPtr = nelmiscJNI.OptFastFloorCWStackPtr_get();
    return (cPtr == 0) ? null : new SWIGTYPE_p_int(cPtr, false);
  }

  public static void setOptFastFloorCWStackEnd(SWIGTYPE_p_int value) {
    nelmiscJNI.OptFastFloorCWStackEnd_set(SWIGTYPE_p_int.getCPtr(value));
  }

  public static SWIGTYPE_p_int getOptFastFloorCWStackEnd() {
    long cPtr = nelmiscJNI.OptFastFloorCWStackEnd_get();
    return (cPtr == 0) ? null : new SWIGTYPE_p_int(cPtr, false);
  }

  public static void OptFastFloorBegin() {
    nelmiscJNI.OptFastFloorBegin();
  }

  public static void OptFastFloorEnd() {
    nelmiscJNI.OptFastFloorEnd();
  }

  public static int OptFastFloor(float x) {
    return nelmiscJNI.OptFastFloor(x);
  }

  public static float OptFastFractionnalPart(float x) {
    return nelmiscJNI.OptFastFractionnalPart(x);
  }

  public static void OptFastFloorBegin24() {
    nelmiscJNI.OptFastFloorBegin24();
  }

  public static void OptFastFloorEnd24() {
    nelmiscJNI.OptFastFloorEnd24();
  }

  public static long OptFastFloor24(float x) {
    return nelmiscJNI.OptFastFloor24(x);
  }

  public static boolean isEqual(CGameDeviceDesc lhs, CGameDeviceDesc rhs) {
    return nelmiscJNI.isEqual__SWIG_0(CGameDeviceDesc.getCPtr(lhs), lhs, CGameDeviceDesc.getCPtr(rhs), rhs);
  }

  public static boolean notEqual(CGameDeviceDesc lhs, CGameDeviceDesc rhs) {
    return nelmiscJNI.notEqual(CGameDeviceDesc.getCPtr(lhs), lhs, CGameDeviceDesc.getCPtr(rhs), rhs);
  }

  public static CHashKeyMD5 getMD5(String filename) {
    return new CHashKeyMD5(nelmiscJNI.getMD5__SWIG_0(filename), true);
  }

  public static CHashKeyMD5 getMD5(SWIGTYPE_p_unsigned_char buffer, long size) {
    return new CHashKeyMD5(nelmiscJNI.getMD5__SWIG_1(SWIGTYPE_p_unsigned_char.getCPtr(buffer), size), true);
  }

  public static long atoihex(String ident) {
    return nelmiscJNI.atoihex(ident);
  }

  public static long atoui(String ident) {
    return nelmiscJNI.atoui(ident);
  }

  public static char getSEPARATOR() {
    return nelmiscJNI.SEPARATOR_get();
  }

  public static int getSEP_SIZE() {
    return nelmiscJNI.SEP_SIZE_get();
  }

  public static boolean isEqual(CPolygon2D lhs, CPolygon2D rhs) {
    return nelmiscJNI.isEqual__SWIG_1(CPolygon2D.getCPtr(lhs), lhs, CPolygon2D.getCPtr(rhs), rhs);
  }

  public static boolean lt(CPolygon2D lhs, CPolygon2D rhs) {
    return nelmiscJNI.lt__SWIG_0(CPolygon2D.getCPtr(lhs), lhs, CPolygon2D.getCPtr(rhs), rhs);
  }

  public static void setReportEmailFunction(SWIGTYPE_p_void emailFunction) {
    nelmiscJNI.setReportEmailFunction(SWIGTYPE_p_void.getCPtr(emailFunction));
  }

  public static CRGBAF mul(float f, CRGBAF c) {
    return new CRGBAF(nelmiscJNI.mul__SWIG_1(f, CRGBAF.getCPtr(c), c), true);
  }

  public static CHashKey getSHA1(String filename, boolean forcePath) {
    return new CHashKey(nelmiscJNI.getSHA1__SWIG_0(filename, forcePath), true);
  }

  public static CHashKey getSHA1(String filename) {
    return new CHashKey(nelmiscJNI.getSHA1__SWIG_1(filename), true);
  }

  public static CHashKey getSHA1(SWIGTYPE_p_unsigned_char buffer, long size) {
    return new CHashKey(nelmiscJNI.getSHA1__SWIG_2(SWIGTYPE_p_unsigned_char.getCPtr(buffer), size), true);
  }

  public static CSString add(char s0, CSString s1) {
    return new CSString(nelmiscJNI.add__SWIG_0(s0, CSString.getCPtr(s1), s1), true);
  }

  public static CSString add(String s0, CSString s1) {
    return new CSString(nelmiscJNI.add__SWIG_1(s0, CSString.getCPtr(s1), s1), true);
  }

  public static String addSlashR(String str) {
    return nelmiscJNI.addSlashR(str);
  }

  public static String removeSlashR(String str) {
    return nelmiscJNI.removeSlashR(str);
  }

  public static int getMaxCStringSize() {
    return nelmiscJNI.MaxCStringSize_get();
  }

  public static int smprintf(String buffer, long count, String format) {
    return nelmiscJNI.smprintf(buffer, count, format);
  }

  public static String toString(String format) {
    return nelmiscJNI.toString__SWIG_0(format);
  }

  public static String toString(short val) {
    return nelmiscJNI.toString__SWIG_2(val);
  }

  public static String toString(char val) {
    return nelmiscJNI.toString__SWIG_3(val);
  }

  public static String toString(long val) {
    return nelmiscJNI.toString__SWIG_4(val);
  }

  public static String toString(int val) {
    return nelmiscJNI.toString__SWIG_5(val);
  }

  public static String toString(java.math.BigInteger val) {
    return nelmiscJNI.toString__SWIG_8(val);
  }

  public static String toString(float val) {
    return nelmiscJNI.toString__SWIG_10(val);
  }

  public static String toString(double val) {
    return nelmiscJNI.toString__SWIG_11(val);
  }

  public static String toString(boolean val) {
    return nelmiscJNI.toString__SWIG_12(val);
  }
/*
  public static boolean fromString(String str, SWIGTYPE_p_unsigned_int val) {
    return nelmiscJNI.fromString__SWIG_1(str, SWIGTYPE_p_unsigned_int.getCPtr(val));
  }

  public static boolean fromString(String str, SWIGTYPE_p_int val) {
    return nelmiscJNI.fromString__SWIG_2(str, SWIGTYPE_p_int.getCPtr(val));
  }
*/
  public static boolean fromString(String str, SWIGTYPE_p_unsigned_char val) {
    return nelmiscJNI.fromString__SWIG_3(str, SWIGTYPE_p_unsigned_char.getCPtr(val));
  }

  public static boolean fromString(String str, SWIGTYPE_p_char val) {
    return nelmiscJNI.fromString__SWIG_4(str, SWIGTYPE_p_char.getCPtr(val));
  }

  public static boolean fromString(String str, SWIGTYPE_p_unsigned_int val) {
    return nelmiscJNI.fromString__SWIG_5(str, SWIGTYPE_p_unsigned_int.getCPtr(val));
  }

  public static boolean fromString(String str, SWIGTYPE_p_int val) {
    return nelmiscJNI.fromString__SWIG_6(str, SWIGTYPE_p_int.getCPtr(val));
  }

  public static boolean fromString(String str, SWIGTYPE_p_unsigned_long_long val) {
    return nelmiscJNI.fromString__SWIG_7(str, SWIGTYPE_p_unsigned_long_long.getCPtr(val));
  }

  public static boolean fromString(String str, SWIGTYPE_p_long_long val) {
    return nelmiscJNI.fromString__SWIG_8(str, SWIGTYPE_p_long_long.getCPtr(val));
  }

  public static boolean fromString(String str, SWIGTYPE_p_float val) {
    return nelmiscJNI.fromString__SWIG_9(str, SWIGTYPE_p_float.getCPtr(val));
  }

  public static boolean fromString(String str, SWIGTYPE_p_double val) {
    return nelmiscJNI.fromString__SWIG_10(str, SWIGTYPE_p_double.getCPtr(val));
  }

  public static boolean fromString(String str, SWIGTYPE_p_bool val) {
    return nelmiscJNI.fromString__SWIG_11(str, SWIGTYPE_p_bool.getCPtr(val));
  }

  public static boolean fromString(String str, SWIGTYPE_p_std__string val) {
    return nelmiscJNI.fromString__SWIG_12(str, SWIGTYPE_p_std__string.getCPtr(val));
  }

  public static ucstring toLower(ucstring str) {
    return new ucstring(nelmiscJNI.toLower__SWIG_3(ucstring.getCPtr(str), str), true);
  }

  public static void toLower(SWIGTYPE_p_ucchar str) {
    nelmiscJNI.toLower__SWIG_4(SWIGTYPE_p_ucchar.getCPtr(str));
  }

  public static ucstring toUpper(ucstring str) {
    return new ucstring(nelmiscJNI.toUpper__SWIG_2(ucstring.getCPtr(str), str), true);
  }

  public static void toUpper(SWIGTYPE_p_ucchar str) {
    nelmiscJNI.toUpper__SWIG_3(SWIGTYPE_p_ucchar.getCPtr(str));
  }

  public static CUV mul(float f, CUV uv) {
    return new CUV(nelmiscJNI.mul__SWIG_2(f, CUV.getCPtr(uv), uv), true);
  }

  public static CUV mul(CUV uv, float f) {
    return new CUV(nelmiscJNI.mul__SWIG_3(CUV.getCPtr(uv), uv, f), true);
  }

  public static CUV blend(CUV uv0, CUV uv1, float lambda) {
    return new CUV(nelmiscJNI.blend__SWIG_2(CUV.getCPtr(uv0), uv0, CUV.getCPtr(uv1), uv1, lambda), true);
  }

  public static CVector blend(CVector v0, CVector v1, float lambda) {
    return new CVector(nelmiscJNI.blend__SWIG_3(CVector.getCPtr(v0), v0, CVector.getCPtr(v1), v1, lambda), true);
  }

  public static CVector2d mul(double f, CVector2d v) {
    return new CVector2d(nelmiscJNI.mul__SWIG_4(f, CVector2d.getCPtr(v), v), true);
  }

  public static CVector2f mul(float f, CVector2f v) {
    return new CVector2f(nelmiscJNI.mul__SWIG_5(f, CVector2f.getCPtr(v), v), true);
  }

  public static boolean lt(CVector2f lhs, CVector2f rhs) {
    return nelmiscJNI.lt__SWIG_1(CVector2f.getCPtr(lhs), lhs, CVector2f.getCPtr(rhs), rhs);
  }

  public static CVector mul(float f, CVector v) {
    return new CVector(nelmiscJNI.mul__SWIG_6(f, CVector.getCPtr(v), v), true);
  }

  public static CVectorD mul(double f, CVectorD v) {
    return new CVectorD(nelmiscJNI.mul__SWIG_7(f, CVectorD.getCPtr(v), v), true);
  }

}
